'use strict'
  class ProductService {
    constructor(rpc_client) {
      this.rpc_client = rpc_client
    }
    /**
    * 查询连锁总店菜单及分组信息
    * @params mid 菜单Id
    * @return
    */
    getMenuWithGroup(mid) {
      return this.rpc_client.request("eleme.product.chain.menu.getMenuWithGroup", {
        mid: mid,
      })
    }
    /**
    * 分页查询连锁总店下的菜单列表
    * @params offset 分页起始
    * @params limit 一页个数
    * @return
    */
    queryMenuByPage(offset, limit) {
      return this.rpc_client.request("eleme.product.chain.menu.queryMenuByPage", {
        offset: offset,
        limit: limit,
      })
    }
    /**
    * 添加连锁总店菜单
    * @params chainMenuBaseDTO 添加的菜单信息
    * @return
    */
    createMenu(chainMenuBaseDTO) {
      return this.rpc_client.request("eleme.product.chain.menu.createMenu", {
        chainMenuBaseDTO: chainMenuBaseDTO,
      })
    }
    /**
    * 更新连锁总店菜单
    * @params mid 菜单Id
    * @params chainMenuBaseDTO 菜单更新信息
    * @return
    */
    updateMenu(mid, chainMenuBaseDTO) {
      return this.rpc_client.request("eleme.product.chain.menu.updateMenu", {
        mid: mid,
        chainMenuBaseDTO: chainMenuBaseDTO,
      })
    }
    /**
    * 删除连锁总店菜单
    * @params mid 菜单Id
    * @return
    */
    deleteMenu(mid) {
      return this.rpc_client.request("eleme.product.chain.menu.deleteMenu", {
        mid: mid,
      })
    }
    /**
    * 查询连锁总店商品分组
    * @params gid 连锁总店商品分组Id
    * @return
    */
    getGroup(gid) {
      return this.rpc_client.request("eleme.product.chain.group.getGroup", {
        gid: gid,
      })
    }
    /**
    * 查询连锁总店商品分组及商品详情
    * @params gid 连锁总店商品分组Id
    * @return
    */
    getGroupWithItem(gid) {
      return this.rpc_client.request("eleme.product.chain.group.getGroupWithItem", {
        gid: gid,
      })
    }
    /**
    * 添加连锁总店商品分组
    * @params mid 菜单Id
    * @params chainGroupBaseDTO 分组创建信息
    * @return
    */
    createGroup(mid, chainGroupBaseDTO) {
      return this.rpc_client.request("eleme.product.chain.group.createGroup", {
        mid: mid,
        chainGroupBaseDTO: chainGroupBaseDTO,
      })
    }
    /**
    * 批量添加连锁总店商品分组
    * @params mid 菜单Id
    * @params chainGroupBaseDTOs 分组创建信息列表
    * @return
    */
    batchCreateGroup(mid, chainGroupBaseDTOs) {
      return this.rpc_client.request("eleme.product.chain.group.batchCreateGroup", {
        mid: mid,
        chainGroupBaseDTOs: chainGroupBaseDTOs,
      })
    }
    /**
    * 更新连锁总店商品分组
    * @params gid 连锁总店商品分组Id
    * @params chainGroupBaseDTO 分组更新信息
    * @return
    */
    updateGroup(gid, chainGroupBaseDTO) {
      return this.rpc_client.request("eleme.product.chain.group.updateGroup", {
        gid: gid,
        chainGroupBaseDTO: chainGroupBaseDTO,
      })
    }
    /**
    * 删除连锁总店商品分组
    * @params gid 连锁总店商品分组Id
    * @return
    */
    deleteGroup(gid) {
      return this.rpc_client.request("eleme.product.chain.group.deleteGroup", {
        gid: gid,
      })
    }
    /**
    * 查询连锁总店商品规格关联的单店商品规格信息
    * @params pId 连锁总店商品规格Id
    * @return
    */
    getRelationByPid(pId) {
      return this.rpc_client.request("eleme.product.chain.pid.getRelationByPid", {
        pId: pId,
      })
    }
    /**
    * 设置连锁总店商品规格与单店商品规格关系
    * @params pId 连锁总店商品规格Id
    * @params specId 子店商品规格Id
    * @return
    */
    setPid(pId, specId) {
      return this.rpc_client.request("eleme.product.chain.pid.setPid", {
        pId: pId,
        specId: specId,
      })
    }
    /**
    * 批量设置连锁总店商品规格与单店商品规格关系
    * @params pId 连锁总店商品规格Id
    * @params specIds 子店商品规格Id列表
    * @return
    */
    batchSetPid(pId, specIds) {
      return this.rpc_client.request("eleme.product.chain.pid.batchSetPid", {
        pId: pId,
        specIds: specIds,
      })
    }
    /**
    * 解除连锁总店商品规格与单店商品规格关系
    * @params specId 子店的商品规格Id
    * @return
    */
    deletePidBySpecId(specId) {
      return this.rpc_client.request("eleme.product.chain.pid.deletePidBySpecId", {
        specId: specId,
      })
    }
    /**
    * 批量解除连锁总店商品规格与单店商品规格关系
    * @params specIds 子店的商品规格Id列表
    * @return
    */
    batchDeletePidBySpecId(specIds) {
      return this.rpc_client.request("eleme.product.chain.pid.batchDeletePidBySpecId", {
        specIds: specIds,
      })
    }
    /**
    * 查询店铺商品分类
    * @params shopId 店铺Id
    * @return
    */
    getShopCategories(shopId) {
      return this.rpc_client.request("eleme.product.category.getShopCategories", {
        shopId: shopId,
      })
    }
    /**
    * 查询店铺商品分类，包含二级分类
    * @params shopId 店铺Id
    * @return
    */
    getShopCategoriesWithChildren(shopId) {
      return this.rpc_client.request("eleme.product.category.getShopCategoriesWithChildren", {
        shopId: shopId,
      })
    }
    /**
    * 查询商品分类详情
    * @params categoryId 商品分类Id
    * @return
    */
    getCategory(categoryId) {
      return this.rpc_client.request("eleme.product.category.getCategory", {
        categoryId: categoryId,
      })
    }
    /**
    * 查询商品分类详情，包含二级分类
    * @params categoryId 商品分类Id
    * @return
    */
    getCategoryWithChildren(categoryId) {
      return this.rpc_client.request("eleme.product.category.getCategoryWithChildren", {
        categoryId: categoryId,
      })
    }
    /**
    * 添加商品分类
    * @params shopId 店铺Id
    * @params name 商品分类名称，长度需在50字以内
    * @params description 商品分类描述，长度需在50字以内
    * @return
    */
    createCategory(shopId, name, description) {
      return this.rpc_client.request("eleme.product.category.createCategory", {
        shopId: shopId,
        name: name,
        description: description,
      })
    }
    /**
    * 添加商品分类，支持二级分类
    * @params shopId 店铺Id
    * @params name 商品分类名称，长度需在50字以内
    * @params parentId 父分类ID，如果没有可以填0
    * @params description 商品分类描述，长度需在50字以内
    * @return
    */
    createCategoryWithChildren(shopId, name, parentId, description) {
      return this.rpc_client.request("eleme.product.category.createCategoryWithChildren", {
        shopId: shopId,
        name: name,
        parentId: parentId,
        description: description,
      })
    }
    /**
    * 更新商品分类
    * @params categoryId 商品分类Id
    * @params name 商品分类名称，长度需在50字以内
    * @params description 商品分类描述，长度需在50字以内
    * @return
    */
    updateCategory(categoryId, name, description) {
      return this.rpc_client.request("eleme.product.category.updateCategory", {
        categoryId: categoryId,
        name: name,
        description: description,
      })
    }
    /**
    * 更新商品分类，包含二级分类
    * @params categoryId 商品分类Id
    * @params name 商品分类名称，长度需在50字以内
    * @params parentId 父分类ID，如果没有可以填0
    * @params description 商品分类描述，长度需在50字以内
    * @return
    */
    updateCategoryWithChildren(categoryId, name, parentId, description) {
      return this.rpc_client.request("eleme.product.category.updateCategoryWithChildren", {
        categoryId: categoryId,
        name: name,
        parentId: parentId,
        description: description,
      })
    }
    /**
    * 删除商品分类
    * @params categoryId 商品分类Id
    * @return
    */
    removeCategory(categoryId) {
      return this.rpc_client.request("eleme.product.category.removeCategory", {
        categoryId: categoryId,
      })
    }
    /**
    * 删除商品分类(新版)
    * @params categoryId 商品分类Id
    * @return
    */
    invalidCategory(categoryId) {
      return this.rpc_client.request("eleme.product.category.invalidCategory", {
        categoryId: categoryId,
      })
    }
    /**
    * 设置分类排序
    * @params shopId 饿了么店铺Id
    * @params categoryIds 需要排序的分类Id
    * @return
    */
    setCategoryPositions(shopId, categoryIds) {
      return this.rpc_client.request("eleme.product.category.setCategoryPositions", {
        shopId: shopId,
        categoryIds: categoryIds,
      })
    }
    /**
    * 设置分类排序(新版)
    * @params shopId 饿了么店铺Id
    * @params categoryIds 需要排序的全部一级分类Id
    * @return
    */
    setCategorySequence(shopId, categoryIds) {
      return this.rpc_client.request("eleme.product.category.setCategorySequence", {
        shopId: shopId,
        categoryIds: categoryIds,
      })
    }
    /**
    * 设置二级分类排序
    * @params shopId 饿了么店铺Id
    * @params categoryWithChildrenIds 需要排序的父分类Id，及其下属的二级分类ID
    * @return
    */
    setCategoryPositionsWithChildren(shopId, categoryWithChildrenIds) {
      return this.rpc_client.request("eleme.product.category.setCategoryPositionsWithChildren", {
        shopId: shopId,
        categoryWithChildrenIds: categoryWithChildrenIds,
      })
    }
    /**
    * 查询商品后台类目
    * @params shopId 店铺Id
    * @return
    */
    getBackCategory(shopId) {
      return this.rpc_client.request("eleme.product.category.getBackCategory", {
        shopId: shopId,
      })
    }
    /**
    * 设置分类类型
    * @params shopId 店铺Id
    * @params categoryId 商品分类Id
    * @params categoryType 分类类型
    * @return
    */
    setCategoryType(shopId, categoryId, categoryType) {
      return this.rpc_client.request("eleme.product.category.setCategoryType", {
        shopId: shopId,
        categoryId: categoryId,
        categoryType: categoryType,
      })
    }
    /**
    * 设置分组分时段置顶
    * @params shopId 店铺Id
    * @params categoryId 商品分类Id
    * @params dayPartingStick 置顶时间设置
    * @return
    */
    setDayPartingStickTime(shopId, categoryId, dayPartingStick) {
      return this.rpc_client.request("eleme.product.category.setDayPartingStickTime", {
        shopId: shopId,
        categoryId: categoryId,
        dayPartingStick: dayPartingStick,
      })
    }
    /**
    * 删除分组的分时置顶功能
    * @params shopId 店铺Id
    * @params categoryId 商品分类Id
    * @return
    */
    removeDayPartingStickTime(shopId, categoryId) {
      return this.rpc_client.request("eleme.product.category.removeDayPartingStickTime", {
        shopId: shopId,
        categoryId: categoryId,
      })
    }
    /**
    * 添加套餐
    * @params categoryId 分类Id
    * @params oPackage 套餐属性
    * @return
    */
    createPackage(categoryId, oPackage) {
      return this.rpc_client.request("eleme.product.package.createPackage", {
        categoryId: categoryId,
        oPackage: oPackage,
      })
    }
    /**
    * 修改套餐基本信息
    * @params itemId 新套餐id即OItem中的商品Id
    * @params categoryId 分类Id即OCategory中的分类Id
    * @params update 套餐基本信息
    * @return
    */
    updatePackageContent(itemId, categoryId, update) {
      return this.rpc_client.request("eleme.product.package.updatePackageContent", {
        itemId: itemId,
        categoryId: categoryId,
        update: update,
      })
    }
    /**
    * 修改套餐和主料的关联关系
    * @params itemId 新套餐id即OItem中的商品Id
    * @params packages 套餐关系
    * @return
    */
    updatePackageRelation(itemId, packages) {
      return this.rpc_client.request("eleme.product.package.updatePackageRelation", {
        itemId: itemId,
        packages: packages,
      })
    }
    /**
    * 删除套餐
    * @params itemId 套餐Id
    * @return
    */
    removePackage(itemId) {
      return this.rpc_client.request("eleme.product.package.removePackage", {
        itemId: itemId,
      })
    }
    /**
    * 获取一个分类下的所有商品
    * @params categoryId 商品分类Id
    * @return
    */
    getItemsByCategoryId(categoryId) {
      return this.rpc_client.request("eleme.product.item.getItemsByCategoryId", {
        categoryId: categoryId,
      })
    }
    /**
    * 查询商品详情
    * @params itemId 商品Id
    * @return
    */
    getItem(itemId) {
      return this.rpc_client.request("eleme.product.item.getItem", {
        itemId: itemId,
      })
    }
    /**
    * 批量查询商品详情
    * @params itemIds 商品Id的列表
    * @return
    */
    batchGetItems(itemIds) {
      return this.rpc_client.request("eleme.product.item.batchGetItems", {
        itemIds: itemIds,
      })
    }
    /**
    * 添加商品
    * @params categoryId 商品分类Id
    * @params properties 商品属性
    * @return
    */
    createItem(categoryId, properties) {
      return this.rpc_client.request("eleme.product.item.createItem", {
        categoryId: categoryId,
        properties: properties,
      })
    }
    /**
    * 批量添加商品
    * @params categoryId 商品分类Id
    * @params items 商品属性的列表
    * @return
    */
    batchCreateItems(categoryId, items) {
      return this.rpc_client.request("eleme.product.item.batchCreateItems", {
        categoryId: categoryId,
        items: items,
      })
    }
    /**
    * 批量添加商品,且忽略异常,专为星巴克开发
    * @params categoryId 商品分类Id
    * @params items 商品属性的列表
    * @return
    */
    batchCreateItemsIgnoreError(categoryId, items) {
      return this.rpc_client.request("eleme.product.item.batchCreateItemsIgnoreError", {
        categoryId: categoryId,
        items: items,
      })
    }
    /**
    * 更新商品
    * @params itemId 商品Id
    * @params categoryId 商品分类Id
    * @params properties 商品属性
    * @return
    */
    updateItem(itemId, categoryId, properties) {
      return this.rpc_client.request("eleme.product.item.updateItem", {
        itemId: itemId,
        categoryId: categoryId,
        properties: properties,
      })
    }
    /**
    * 批量置满库存
    * @params specIds 商品及商品规格的列表
    * @return
    */
    batchFillStock(specIds) {
      return this.rpc_client.request("eleme.product.item.batchFillStock", {
        specIds: specIds,
      })
    }
    /**
    * 批量沽清库存
    * @params specIds 商品及商品规格的列表
    * @return
    */
    batchClearStock(specIds) {
      return this.rpc_client.request("eleme.product.item.batchClearStock", {
        specIds: specIds,
      })
    }
    /**
    * 批量上架商品
    * @params specIds 商品及商品规格的列表
    * @return
    */
    batchOnShelf(specIds) {
      return this.rpc_client.request("eleme.product.item.batchOnShelf", {
        specIds: specIds,
      })
    }
    /**
    * 批量上架商品(新版)
    * @params itemIds 商品ID列表
    * @return
    */
    batchListItems(itemIds) {
      return this.rpc_client.request("eleme.product.item.batchListItems", {
        itemIds: itemIds,
      })
    }
    /**
    * 批量下架商品
    * @params specIds 商品及商品规格的列表
    * @return
    */
    batchOffShelf(specIds) {
      return this.rpc_client.request("eleme.product.item.batchOffShelf", {
        specIds: specIds,
      })
    }
    /**
    * 批量下架商品(新版)
    * @params itemIds 商品ID列表
    * @return
    */
    batchDelistItems(itemIds) {
      return this.rpc_client.request("eleme.product.item.batchDelistItems", {
        itemIds: itemIds,
      })
    }
    /**
    * 删除商品
    * @params itemId 商品Id
    * @return
    */
    removeItem(itemId) {
      return this.rpc_client.request("eleme.product.item.removeItem", {
        itemId: itemId,
      })
    }
    /**
    * 删除商品(新版)
    * @params itemId 商品Id
    * @return
    */
    invalidItem(itemId) {
      return this.rpc_client.request("eleme.product.item.invalidItem", {
        itemId: itemId,
      })
    }
    /**
    * 批量删除商品
    * @params itemIds 商品Id的列表
    * @return
    */
    batchRemoveItems(itemIds) {
      return this.rpc_client.request("eleme.product.item.batchRemoveItems", {
        itemIds: itemIds,
      })
    }
    /**
    * 批量更新商品库存
    * @params specStocks 商品以及规格库存列表
    * @return
    */
    batchUpdateSpecStocks(specStocks) {
      return this.rpc_client.request("eleme.product.item.batchUpdateSpecStocks", {
        specStocks: specStocks,
      })
    }
    /**
    * 批量更新商品库存(新版)
    * @params stockMap 商品规格ID和库存设值的映射
    * @return
    */
    batchUpdateStock(stockMap) {
      return this.rpc_client.request("eleme.product.item.batchUpdateStock", {
        stockMap: stockMap,
      })
    }
    /**
    * 设置商品排序
    * @params categoryId 商品分类Id
    * @params itemIds 商品Id列表
    * @return
    */
    setItemPositions(categoryId, itemIds) {
      return this.rpc_client.request("eleme.product.item.setItemPositions", {
        categoryId: categoryId,
        itemIds: itemIds,
      })
    }
    /**
    * 批量沽清库存并在次日2:00开始置满
    * @params clearStocks 店铺Id及商品Id的列表
    * @return
    */
    clearAndTimingMaxStock(clearStocks) {
      return this.rpc_client.request("eleme.product.item.clearAndTimingMaxStock", {
        clearStocks: clearStocks,
      })
    }
    /**
    * 根据商品扩展码获取商品
    * @params shopId 店铺Id
    * @params extendCode 商品扩展码
    * @return
    */
    getItemByShopIdAndExtendCode(shopId, extendCode) {
      return this.rpc_client.request("eleme.product.item.getItemByShopIdAndExtendCode", {
        shopId: shopId,
        extendCode: extendCode,
      })
    }
    /**
    * 根据商品条形码获取商品
    * @params shopId 店铺Id
    * @params barCode 商品条形码
    * @return
    */
    getItemsByShopIdAndBarCode(shopId, barCode) {
      return this.rpc_client.request("eleme.product.item.getItemsByShopIdAndBarCode", {
        shopId: shopId,
        barCode: barCode,
      })
    }
    /**
    * 批量修改商品价格
    * @params shopId 店铺Id
    * @params specPrices 商品Id及其下SkuId和价格对应Map(限制最多50个)
    * @return
    */
    batchUpdatePrices(shopId, specPrices) {
      return this.rpc_client.request("eleme.product.item.batchUpdatePrices", {
        shopId: shopId,
        specPrices: specPrices,
      })
    }
    /**
    * 查询活动商品
    * @params shopId 店铺Id
    * @return
    */
    getItemIdsHasActivityByShopId(shopId) {
      return this.rpc_client.request("eleme.product.item.getItemIdsHasActivityByShopId", {
        shopId: shopId,
      })
    }
    /**
    * 查询店铺活动商品(新版)
    * @params shopId 店铺Id
    * @return
    */
    getShopSalesItems(shopId) {
      return this.rpc_client.request("eleme.product.item.getShopSalesItems", {
        shopId: shopId,
      })
    }
    /**
    * 设置订单餐盒费
    * @params shopId  店铺ID
    * @params status 是否按照订单设置餐盒费
    * @params packingFee 订单餐盒费费用
    * @return
    */
    setOrderPackingFee(shopId, status, packingFee) {
      return this.rpc_client.request("eleme.product.item.setOrderPackingFee", {
        shopId: shopId,
        status: status,
        packingFee: packingFee,
      })
    }
    /**
    * 分页获取店铺下的商品
    * @params queryPage 分页查询参数
    * @return
    */
    queryItemByPage(queryPage) {
      return this.rpc_client.request("eleme.product.item.queryItemByPage", {
        queryPage: queryPage,
      })
    }
    /**
    * 获取原材料树
    * @params shopId 店铺ID
    * @return
    */
    getMaterialTree(shopId) {
      return this.rpc_client.request("eleme.product.item.getMaterialTree", {
        shopId: shopId,
      })
    }
    /**
    * 主料关联配料
    * @params shopId 店铺ID
    * @params mainItemId 主料ID（商品ID）
    * @params ingredientGroup  商品配料分组
    * @return
    */
    setIngredient(shopId, mainItemId, ingredientGroup) {
      return this.rpc_client.request("eleme.product.item.setIngredient", {
        shopId: shopId,
        mainItemId: mainItemId,
        ingredientGroup: ingredientGroup,
      })
    }
    /**
    * 删除配料
    * @params shopId 店铺ID
    * @params mainItemId 主料ID（商品ID）
    * @return
    */
    removeIngredient(shopId, mainItemId) {
      return this.rpc_client.request("eleme.product.item.removeIngredient", {
        shopId: shopId,
        mainItemId: mainItemId,
      })
    }
    /**
    * 针对主菜itemId设置菜品推荐
    * @params shopId 店铺ID
    * @params itemId 商品ID
    * @params relatedItemIds 关联的商品ID
    * @return
    */
    setRelatedItemIds(shopId, itemId, relatedItemIds) {
      return this.rpc_client.request("eleme.product.item.setRelatedItemIds", {
        shopId: shopId,
        itemId: itemId,
        relatedItemIds: relatedItemIds,
      })
    }
    /**
    * 对主菜itemId设置是否开启菜品推荐
    * @params shopId 店铺ID
    * @params itemId 商品ID
    * @params display 是否展示
    * @return
    */
    displayRelatedItemIds(shopId, itemId, display) {
      return this.rpc_client.request("eleme.product.item.displayRelatedItemIds", {
        shopId: shopId,
        itemId: itemId,
        display: display,
      })
    }
    /**
    * 针对主菜itemId查询菜品推荐
    * @params shopId 店铺ID
    * @params itemId 商品ID
    * @return
    */
    getRelatedItemIds(shopId, itemId) {
      return this.rpc_client.request("eleme.product.item.getRelatedItemIds", {
        shopId: shopId,
        itemId: itemId,
      })
    }
    /**
    * 添加多规格商品
    * @params categoryId 商品分类Id
    * @params properties 商品属性
    * @return
    */
    createMultiSpecItem(categoryId, properties) {
      return this.rpc_client.request("eleme.product.item.createMultiSpecItem", {
        categoryId: categoryId,
        properties: properties,
      })
    }
    /**
    * 批量添加多规格商品
    * @params categoryId 商品分类Id
    * @params items 商品属性的列表
    * @return
    */
    batchCreateMultiSpecItem(categoryId, items) {
      return this.rpc_client.request("eleme.product.item.batchCreateMultiSpecItem", {
        categoryId: categoryId,
        items: items,
      })
    }
    /**
    * 更新多规格商品
    * @params itemId 商品Id
    * @params categoryId 商品分类Id
    * @params properties 商品属性
    * @return
    */
    updateMultiSpecItem(itemId, categoryId, properties) {
      return this.rpc_client.request("eleme.product.item.updateMultiSpecItem", {
        itemId: itemId,
        categoryId: categoryId,
        properties: properties,
      })
    }
    /**
    * 设置配料组数据
    * @params itemId 商品Id
    * @params groupRelations 配料组信息
    * @return
    */
    setIngredientGroup(itemId, groupRelations) {
      return this.rpc_client.request("eleme.product.item.setIngredientGroup", {
        itemId: itemId,
        groupRelations: groupRelations,
      })
    }
    /**
    * 删除配料组数据
    * @params itemId 商品Id
    * @return
    */
    removeIngredientGroup(itemId) {
      return this.rpc_client.request("eleme.product.item.removeIngredientGroup", {
        itemId: itemId,
      })
    }
    /**
    * 查询连锁总店商品信息
    * @params iid 连锁总店商品Id
    * @return
    */
    getChainItem(iid) {
      return this.rpc_client.request("eleme.product.chain.item.getChainItem", {
        iid: iid,
      })
    }
    /**
    * 批量查询连锁总店商品信息
    * @params iids 连锁总店商品Id列表
    * @return
    */
    batchGetChainItem(iids) {
      return this.rpc_client.request("eleme.product.chain.item.batchGetChainItem", {
        iids: iids,
      })
    }
    /**
    * 添加连锁总店商品
    * @params gid 连锁总店商品分组Id
    * @params chainItemBaseDTO 商品创建信息
    * @return
    */
    createChainItem(gid, chainItemBaseDTO) {
      return this.rpc_client.request("eleme.product.chain.item.createChainItem", {
        gid: gid,
        chainItemBaseDTO: chainItemBaseDTO,
      })
    }
    /**
    * 批量添加连锁总店商品
    * @params gid 连锁总店商品分组Id
    * @params chainItemBaseDTOs 商品创建信息列表
    * @return
    */
    batchCreateChainItem(gid, chainItemBaseDTOs) {
      return this.rpc_client.request("eleme.product.chain.item.batchCreateChainItem", {
        gid: gid,
        chainItemBaseDTOs: chainItemBaseDTOs,
      })
    }
    /**
    * 替换连锁总店商品
    * @params gid 商品分组Id
    * @params chainItemDTO 商品替换信息
    * @return
    */
    replaceChainItem(gid, chainItemDTO) {
      return this.rpc_client.request("eleme.product.chain.item.replaceChainItem", {
        gid: gid,
        chainItemDTO: chainItemDTO,
      })
    }
    /**
    * 批量替换连锁总店商品
    * @params gid 商品分组Id
    * @params chainItemDTOs 商品替换信息列表
    * @return
    */
    batchReplaceChainItem(gid, chainItemDTOs) {
      return this.rpc_client.request("eleme.product.chain.item.batchReplaceChainItem", {
        gid: gid,
        chainItemDTOs: chainItemDTOs,
      })
    }
    /**
    * 更新连锁总店商品不包含规格信息
    * @params iid 连锁总店商品Id
    * @params chainItemBaseDTO 商品更新信息
    * @return
    */
    updateChainItemWithoutSku(iid, chainItemBaseDTO) {
      return this.rpc_client.request("eleme.product.chain.item.updateChainItemWithoutSku", {
        iid: iid,
        chainItemBaseDTO: chainItemBaseDTO,
      })
    }
    /**
    * 删除连锁总店商品
    * @params iid 连锁总店商品Id
    * @return
    */
    deleteChainItem(iid) {
      return this.rpc_client.request("eleme.product.chain.item.deleteChainItem", {
        iid: iid,
      })
    }
    /**
    * 查询连锁总店商品规格
    * @params pId 连锁总店商品规格Id
    * @return
    */
    getSku(pId) {
      return this.rpc_client.request("eleme.product.chain.item.getSku", {
        pId: pId,
      })
    }
    /**
    * 新增连锁总店商品规格
    * @params iid 连锁总店商品Id
    * @params chainSkuBaseDTO 添加规格信息
    * @return
    */
    addSku(iid, chainSkuBaseDTO) {
      return this.rpc_client.request("eleme.product.chain.item.addSku", {
        iid: iid,
        chainSkuBaseDTO: chainSkuBaseDTO,
      })
    }
    /**
    * 更新连锁总店商品规格
    * @params pId 连锁总店商品规格Id
    * @params chainSkuBaseDTO 规格更新信息
    * @return
    */
    updateSku(pId, chainSkuBaseDTO) {
      return this.rpc_client.request("eleme.product.chain.item.updateSku", {
        pId: pId,
        chainSkuBaseDTO: chainSkuBaseDTO,
      })
    }
    /**
    * 删除连锁总店商品规格
    * @params pId 连锁总店商品规格Id
    * @return
    */
    deleteSku(pId) {
      return this.rpc_client.request("eleme.product.chain.item.deleteSku", {
        pId: pId,
      })
    }
    /**
    * 上传图片，返回图片的hash值
    * @params image 文件内容base64编码值
    * @return
    */
    uploadImage(image) {
      return this.rpc_client.request("eleme.file.uploadImage", {
        image: image,
      })
    }
    /**
    * 通过远程URL上传图片，返回图片的hash值
    * @params url 远程Url地址
    * @return
    */
    uploadImageWithRemoteUrl(url) {
      return this.rpc_client.request("eleme.file.uploadImageWithRemoteUrl", {
        url: url,
      })
    }
    /**
    * 获取上传文件的访问URL，返回文件的Url地址
    * @params hash 图片hash值
    * @return
    */
    getUploadedUrl(hash) {
      return this.rpc_client.request("eleme.file.getUploadedUrl", {
        hash: hash,
      })
    }
    /**
    * 获取上传图片的url地址(新版)
    * @params hash 图片hash值
    * @return
    */
    getImageUrl(hash) {
      return this.rpc_client.request("eleme.file.getImageUrl", {
        hash: hash,
      })
    }
}

module.exports = ProductService